home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / gfp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  8.4 KB  |  254 lines
  1. #ifndef __LINUX_GFP_H
  2. #define __LINUX_GFP_H
  3.  
  4. #include <linux/mmzone.h>
  5. #include <linux/stddef.h>
  6. #include <linux/linkage.h>
  7.  
  8. struct vm_area_struct;
  9.  
  10. /*
  11.  * GFP bitmasks..
  12.  *
  13.  * Zone modifiers (see linux/mmzone.h - low three bits)
  14.  *
  15.  * Do not put any conditional on these. If necessary modify the definitions
  16.  * without the underscores and use the consistently. The definitions here may
  17.  * be used in bit comparisons.
  18.  */
  19. #define __GFP_DMA    ((__force gfp_t)0x01u)
  20. #define __GFP_HIGHMEM    ((__force gfp_t)0x02u)
  21. #define __GFP_DMA32    ((__force gfp_t)0x04u)
  22.  
  23. /*
  24.  * Action modifiers - doesn't change the zoning
  25.  *
  26.  * __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
  27.  * _might_ fail.  This depends upon the particular VM implementation.
  28.  *
  29.  * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
  30.  * cannot handle allocation failures.
  31.  *
  32.  * __GFP_NORETRY: The VM implementation must not retry indefinitely.
  33.  *
  34.  * __GFP_MOVABLE: Flag that this page will be movable by the page migration
  35.  * mechanism or reclaimed
  36.  */
  37. #define __GFP_WAIT    ((__force gfp_t)0x10u)    /* Can wait and reschedule? */
  38. #define __GFP_HIGH    ((__force gfp_t)0x20u)    /* Should access emergency pools? */
  39. #define __GFP_IO    ((__force gfp_t)0x40u)    /* Can start physical IO? */
  40. #define __GFP_FS    ((__force gfp_t)0x80u)    /* Can call down to low-level FS? */
  41. #define __GFP_COLD    ((__force gfp_t)0x100u)    /* Cache-cold page required */
  42. #define __GFP_NOWARN    ((__force gfp_t)0x200u)    /* Suppress page allocation failure warning */
  43. #define __GFP_REPEAT    ((__force gfp_t)0x400u)    /* See above */
  44. #define __GFP_NOFAIL    ((__force gfp_t)0x800u)    /* See above */
  45. #define __GFP_NORETRY    ((__force gfp_t)0x1000u)/* See above */
  46. #define __GFP_COMP    ((__force gfp_t)0x4000u)/* Add compound page metadata */
  47. #define __GFP_ZERO    ((__force gfp_t)0x8000u)/* Return zeroed page on success */
  48. #define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */
  49. #define __GFP_HARDWALL   ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */
  50. #define __GFP_THISNODE    ((__force gfp_t)0x40000u)/* No fallback, no policies */
  51. #define __GFP_RECLAIMABLE ((__force gfp_t)0x80000u) /* Page is reclaimable */
  52. #define __GFP_MOVABLE    ((__force gfp_t)0x100000u)  /* Page is movable */
  53.  
  54. #define __GFP_BITS_SHIFT 21    /* Room for 21 __GFP_FOO bits */
  55. #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
  56.  
  57. /* This equals 0, but use constants in case they ever change */
  58. #define GFP_NOWAIT    (GFP_ATOMIC & ~__GFP_HIGH)
  59. /* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */
  60. #define GFP_ATOMIC    (__GFP_HIGH)
  61. #define GFP_NOIO    (__GFP_WAIT)
  62. #define GFP_NOFS    (__GFP_WAIT | __GFP_IO)
  63. #define GFP_KERNEL    (__GFP_WAIT | __GFP_IO | __GFP_FS)
  64. #define GFP_TEMPORARY    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
  65.              __GFP_RECLAIMABLE)
  66. #define GFP_USER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
  67. #define GFP_HIGHUSER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \
  68.              __GFP_HIGHMEM)
  69. #define GFP_HIGHUSER_MOVABLE    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
  70.                  __GFP_HARDWALL | __GFP_HIGHMEM | \
  71.                  __GFP_MOVABLE)
  72. #define GFP_NOFS_PAGECACHE    (__GFP_WAIT | __GFP_IO | __GFP_MOVABLE)
  73. #define GFP_USER_PAGECACHE    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
  74.                  __GFP_HARDWALL | __GFP_MOVABLE)
  75. #define GFP_HIGHUSER_PAGECACHE    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
  76.                  __GFP_HARDWALL | __GFP_HIGHMEM | \
  77.                  __GFP_MOVABLE)
  78.  
  79. #ifdef CONFIG_NUMA
  80. #define GFP_THISNODE    (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
  81. #else
  82. #define GFP_THISNODE    ((__force gfp_t)0)
  83. #endif
  84.  
  85. /* This mask makes up all the page movable related flags */
  86. #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
  87.  
  88. /* Control page allocator reclaim behavior */
  89. #define GFP_RECLAIM_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS|\
  90.             __GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\
  91.             __GFP_NORETRY|__GFP_NOMEMALLOC)
  92.  
  93. /* Control allocation constraints */
  94. #define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE)
  95.  
  96. /* Do not use these with a slab allocator */
  97. #define GFP_SLAB_BUG_MASK (__GFP_DMA32|__GFP_HIGHMEM|~__GFP_BITS_MASK)
  98.  
  99. /* Flag - indicates that the buffer will be suitable for DMA.  Ignored on some
  100.    platforms, used as appropriate on others */
  101.  
  102. #define GFP_DMA        __GFP_DMA
  103.  
  104. /* 4GB DMA on some platforms */
  105. #define GFP_DMA32    __GFP_DMA32
  106.  
  107. /* Convert GFP flags to their corresponding migrate type */
  108. static inline int allocflags_to_migratetype(gfp_t gfp_flags)
  109. {
  110.     WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
  111.  
  112.     if (unlikely(page_group_by_mobility_disabled))
  113.         return MIGRATE_UNMOVABLE;
  114.  
  115.     /* Group based on mobility */
  116.     return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
  117.         ((gfp_flags & __GFP_RECLAIMABLE) != 0);
  118. }
  119.  
  120. static inline enum zone_type gfp_zone(gfp_t flags)
  121. {
  122. #ifdef CONFIG_ZONE_DMA
  123.     if (flags & __GFP_DMA)
  124.         return ZONE_DMA;
  125. #endif
  126. #ifdef CONFIG_ZONE_DMA32
  127.     if (flags & __GFP_DMA32)
  128.         return ZONE_DMA32;
  129. #endif
  130.     if ((flags & (__GFP_HIGHMEM | __GFP_MOVABLE)) ==
  131.             (__GFP_HIGHMEM | __GFP_MOVABLE))
  132.         return ZONE_MOVABLE;
  133. #ifdef CONFIG_HIGHMEM
  134.     if (flags & __GFP_HIGHMEM)
  135.         return ZONE_HIGHMEM;
  136. #endif
  137.     return ZONE_NORMAL;
  138. }
  139.  
  140. /*
  141.  * There is only one page-allocator function, and two main namespaces to
  142.  * it. The alloc_page*() variants return 'struct page *' and as such
  143.  * can allocate highmem pages, the *get*page*() variants return
  144.  * virtual kernel addresses to the allocated page(s).
  145.  */
  146.  
  147. static inline int gfp_zonelist(gfp_t flags)
  148. {
  149.     if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
  150.         return 1;
  151.  
  152.     return 0;
  153. }
  154.  
  155. /*
  156.  * We get the zone list from the current node and the gfp_mask.
  157.  * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones.
  158.  * There are two zonelists per node, one for all zones with memory and
  159.  * one containing just zones from the node the zonelist belongs to.
  160.  *
  161.  * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets
  162.  * optimized to &contig_page_data at compile-time.
  163.  */
  164. static inline struct zonelist *node_zonelist(int nid, gfp_t flags)
  165. {
  166.     return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags);
  167. }
  168.  
  169. #ifndef HAVE_ARCH_FREE_PAGE
  170. static inline void arch_free_page(struct page *page, int order) { }
  171. #endif
  172. #ifndef HAVE_ARCH_ALLOC_PAGE
  173. static inline void arch_alloc_page(struct page *page, int order) { }
  174. #endif
  175.  
  176. struct page *
  177. __alloc_pages_internal(gfp_t gfp_mask, unsigned int order,
  178.                struct zonelist *zonelist, nodemask_t *nodemask);
  179.  
  180. static inline struct page *
  181. __alloc_pages(gfp_t gfp_mask, unsigned int order,
  182.         struct zonelist *zonelist)
  183. {
  184.     return __alloc_pages_internal(gfp_mask, order, zonelist, NULL);
  185. }
  186.  
  187. static inline struct page *
  188. __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
  189.         struct zonelist *zonelist, nodemask_t *nodemask)
  190. {
  191.     return __alloc_pages_internal(gfp_mask, order, zonelist, nodemask);
  192. }
  193.  
  194.  
  195. static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
  196.                         unsigned int order)
  197. {
  198.     if (unlikely(order >= MAX_ORDER))
  199.         return NULL;
  200.  
  201.     /* Unknown node is current node */
  202.     if (nid < 0)
  203.         nid = numa_node_id();
  204.  
  205.     return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
  206. }
  207.  
  208. #ifdef CONFIG_NUMA
  209. extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
  210.  
  211. static inline struct page *
  212. alloc_pages(gfp_t gfp_mask, unsigned int order)
  213. {
  214.     if (unlikely(order >= MAX_ORDER))
  215.         return NULL;
  216.  
  217.     return alloc_pages_current(gfp_mask, order);
  218. }
  219. extern struct page *alloc_page_vma(gfp_t gfp_mask,
  220.             struct vm_area_struct *vma, unsigned long addr);
  221. #else
  222. #define alloc_pages(gfp_mask, order) \
  223.         alloc_pages_node(numa_node_id(), gfp_mask, order)
  224. #define alloc_page_vma(gfp_mask, vma, addr) alloc_pages(gfp_mask, 0)
  225. #endif
  226. #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
  227.  
  228. extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
  229. extern unsigned long get_zeroed_page(gfp_t gfp_mask);
  230.  
  231. void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
  232. void free_pages_exact(void *virt, size_t size);
  233.  
  234. #define __get_free_page(gfp_mask) \
  235.         __get_free_pages((gfp_mask),0)
  236.  
  237. #define __get_dma_pages(gfp_mask, order) \
  238.         __get_free_pages((gfp_mask) | GFP_DMA,(order))
  239.  
  240. extern void __free_pages(struct page *page, unsigned int order);
  241. extern void free_pages(unsigned long addr, unsigned int order);
  242. extern void free_hot_page(struct page *page);
  243. extern void free_cold_page(struct page *page);
  244.  
  245. #define __free_page(page) __free_pages((page), 0)
  246. #define free_page(addr) free_pages((addr),0)
  247.  
  248. void page_alloc_init(void);
  249. void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
  250. void drain_all_pages(void);
  251. void drain_local_pages(void *dummy);
  252.  
  253. #endif /* __LINUX_GFP_H */
  254.